package OODay04_Day10;

public class Day10 {
    public static void main(String[] args) {
        //多态(重点)
        //即多种形态
        //生活中的多态
        //   水---固态 液态 气态---形态不同 功能不同
        //   人---母亲 老师 老婆---形态不同 功能不同

        //软件中的多态
        //通过<向上造型>语法实现多态
        //1  超类型的引用指向派生类的对象
        //(Java规定超类一定要大于派生类)
        /*class Animal{
        }
        class Dog extends Animal{
        }*/
        //Animal o=new Animal();//动物对象是动物类的---动物是动物
        //Dog o=new Dog();//狗是狗
        //Animal o=new Dog();//狗对象是动物类的---狗是动物---向上造型
        //Dog o=new Animal();//编译错误 动物是狗

        //造型时 小类型自动转大类型

        //2  能点出什么来 看<引用>的类型
        /*Person p1=new Teacher(\..);
        * Person p2=new Students(\..);
        * Person p3=new Doctor(\..);
        * p1./p2./p3.只能点出Person类的内容 点不出Teacher/Students/Doctor特有的内容*/

        //3  可以向上造型成为的类型有:所继承的类 所实现的接口
        /*Student p1=new Student(\..);---学生是学生
        * Person p1=new Student(\..);---学生是人---向上造型---不再具备学生类特有的功能 只有Person类的功能
        * Swim dog=new Dog();---小狗会游泳
        * <从右往左念>*/

        //向下转型何时用 若想访问的属性或行为<在超类里没有> 需要向下转型
        //向下转型/强制类型转换(引用类型强转时 可能会失败)
        //成功条件有两种
        //1 引用指向的对象 就是该类型
        //2 引用指向的对象 实现了该接口或继承了该类
        //举例
        //Animal o1=new Dog(\..);
        //看对象(Dog),可以转为Dog Swim Animal(本身就是Animal类)

        //若不符合上述条件 会发生ClassCastException 类型转换异常
        //举例
        //Animal o1=new Dog(\..);
        //Dog d=(Dog)o1;
        //Swim s=(Swim)o1;
        //Fish f=(Fish)o1;//运行时发生异常

        //建议 在强转之前先通过instanceof判断引用指向的对象是否为该类型


        //内部类(重难点)
        //命名 : 外部类名 $ 内部类名 .class
        //成员内部类(应用率低) 匿名内部类(应用率高)
        //成员内部类 类中套类 外面的称为外部类 里面的称为内部类
        //class Aoo{---外部类
        //   class Boo{---内部类
        //  }
        //}
        //外部类是独立的类 内部类不是独立的类
        //内部类通常只服务于外部类 对外不具备可见性
        //内部类对象通常在外部类中创建
        //内部类中可以直接访问外部类的成员
        //内部类中有一个隐式的引用指向了创建它的外部类对象---外部类名.this(外部类名.this.外部类内容<如成员变量>)

        //何时用 若Boo类只让Aoo类用 并且Boo还想访问Aoo类的成员时 可以设计成员内部类 可以稍微简化代码

        //补充 隐式的引用
        //1 this 指代当前对象
        //2 super 指代当前对象的父类对象
        //3 外部类名.this 指代外部类对象


        //匿名内部类(重难点)
        //1 何时用 有严格限制
        //若想创建一个<派生类>的对象 并且对象<只创建一次> 可以设计成<匿名内部类> 可以大大简化代码
        //例如做月饼 一堆月饼 可以做一个模子 若要做一个月饼艺术品 独一无二的

        /**public class Aooo{
            public static void main(String[] args) {
         //1 创建了一个Inter的派生类 但是没有名字
         //2 为该派生类创建了一个对象 名为o1 向上造型为Inter型
         //---new Inter(){};是在创建Inter的派生类的对象
                Inter o1=new Inter(){};
            }
        }
        interface Inter{}//Inter接口
        Inter o3=new Aoo();
        class Aoo implements Inter{}*/

        //2 注意 匿名内部类的里面 不能修改外面局部变量的值
        //      因为该变量在匿名内部类中默认为final的

        //3 面试题
        //内部类中有默认的.class字节码文件吗
        //有 只要是类 编译时都会有自己的字节码文件
        //src文件夹装的是源代码文件(.Java文件)
        //out中装的是所有的.class字节码文件


        //package和import

        //package 用于声明包
        //作用 避免类的命名冲突 java规定 不同包之间的类可以同名 但是包中的类之间不能同名
           //为什么不同包之间类可以同名 因为java中 类的全名为 包名.类名
        //建议 包名常常有层次结构 所有字母都小写

        //import 用于导入包中的类
        //Java规则 同包中的类可以直接访问 不同包之间的类不能直接访问
        //若想访问 1 直接写类的全称<包名.类名>------------(太繁琐 不建议
              // 2 可以先import导入类再使用类
                  //注意 import一定要写在package的下面 依旧是写全称 但是只需要写一遍----(建议使用
      /**  package a;
        class Aoo{
        }

        package b;
        import a.Aoo;--------------导入a包中的Aoo类
        class Boo{
            public static void main(String[] args) {
                Aoo o=new Aoo();
            }
        }*/
      //注意---关键词顺序若三者同时出现 顺序为 package---import---class


        //Scanner
        /** import Java.util.Scanner;
         * Scanner scan=new Scanner(System.in);
         * int age=scan.nextInt();
         * double price=scan.nextDouble();*/
        /** package java.util
         * class Scanner{
         *     Scanner(InputStream s){\..}
         *     int nextInt(){}
         *     double nextDouble(){}
         * }
         * */
    }
}
